ViewModel + Koin in a commonMain  -  Compose Multiplatform

Summary

Cette vidéo présente la mise en place d'un projet Kotlin Multiplatform (KMP) avec deux écrans et deux ViewModels, permettant de partager du code entre Android et iOS. L'intégration de la bibliothèque de navigation Compose et de Coin pour l'injection de dépendances est expliquée. Le processus inclut la création de modules Coin pour injecter un dépôt dans les ViewModels, ainsi que l'utilisation de Composable Context pour gérer les dépendances dans les écrans. L'application est testée sur un émulateur Android et un simulateur iOS pour démontrer le comportement synchronisé des ViewModels entre les plateformes.

Takeaways

• 😀 Un projet Kotlin Multiplatform (KMP) permet de partager le même modèle de vue pour Android et iOS à partir d'une base de code unique.
• 😀 L'utilisation de la bibliothèque officielle de navigation Compose permet de gérer facilement la navigation entre les écrans sur les deux plateformes.
• 😀 Le framework Coin est utilisé pour l'injection de dépendances, permettant de partager un repository unique entre les ViewModels sur Android et iOS.
• 😀 La gestion des ViewModels à l'aide de Coin garantit une injection de dépendances cohérente et un cycle de vie approprié pour les deux plateformes.
• 😀 Les ViewModels sont injectés dans les Composables grâce à la fonction `viewModel()` de Coin, ce qui simplifie l'architecture de l'application.
• 😀 L'injection de dépendances dans KMP se fait via des modules Coin définis dans un fichier Kotlin commun, permettant de partager la logique entre Android et iOS.
• 😀 Le repository est injecté en tant que singleton, garantissant qu'une seule instance de ce repository est utilisée pendant toute la durée de vie de l'application.
• 😀 L'application utilise des fonctions comme `CoinContextComposable` pour délimiter les contextes d'injection de dépendances dans les Composables.
• 😀 Les étapes de configuration incluent l'ajout des dépendances nécessaires à la bibliothèque Compose Navigation, Lifecycle et Coin dans le projet KMP.
• 😀 Après l'initialisation des dépendances dans le fichier `MainActivity` d'Android et le fichier Swift d'iOS, l'application fonctionne de manière cohérente sur les deux plateformes.
• 😀 Lors de l'exécution de l'application, les ViewModels sont initialisés et détruits correctement en fonction de la navigation entre les écrans, offrant ainsi une expérience utilisateur fluide sur Android et iOS.

Q & A

Qu'est-ce qu'un projet Kotlin Multiplatform (KMP) et comment est-il utilisé dans cet exemple ?

Un projet Kotlin Multiplatform (KMP) permet de partager du code entre différentes plateformes, comme iOS et Android. Dans cet exemple, il est utilisé pour développer une application mobile où le code des vues et des ViewModels peut être partagé entre les deux plateformes, réduisant ainsi la duplication du code.

Pourquoi utiliser la bibliothèque Coin pour l'injection de dépendances ?

Coin est utilisé pour gérer l'injection de dépendances de manière simple et légère. Dans cet exemple, Coin est utilisé pour injecter un repository dans les ViewModels et pour fournir les ViewModels aux fonctions Composables, simplifiant la gestion des dépendances entre les différents composants de l'application.

Comment la navigation entre les écrans est-elle gérée dans cet exemple ?

La navigation est gérée via la bibliothèque Compose Navigation, qui permet de définir les écrans de manière déclarative et de naviguer facilement entre eux. Dans l'exemple, un bouton sur chaque écran permet de naviguer entre l'écran d'accueil et l'écran de détail.

Que fait exactement le ViewModel dans cet exemple ?

Le ViewModel dans cet exemple ne fait pas de logique complexe mais est utilisé pour illustrer l'initialisation et la destruction des objets. Il affiche simplement un message dans les logs lorsqu'il est initialisé ou détruit, permettant ainsi de visualiser le cycle de vie des ViewModels lors de la navigation.

Qu'est-ce qu'un 'CoinModule' et pourquoi est-il important ?

Un 'CoinModule' est une définition dans Coin qui déclare comment les dépendances (comme les ViewModels ou repositories) doivent être créées et injectées dans l'application. Dans cet exemple, il est utilisé pour déclarer l'injection des ViewModels et du repository dans les composants de l'application.

Pourquoi les ViewModels sont-ils injectés comme singletons dans cet exemple ?

Les ViewModels sont injectés comme singletons afin d'assurer qu'une seule instance de chaque ViewModel soit disponible durant toute la durée de vie de l'application. Cela permet d'éviter la recréation des ViewModels à chaque changement d'écran, ce qui est plus performant et logique.

Comment Coin gère-t-il l'injection de dépendances dans les composables ?

Coin gère l'injection dans les composables en utilisant la fonction 'coinViewModel()'. Cette fonction permet d'injecter les ViewModels directement dans les composables, garantissant que les dépendances sont injectées de manière fluide au moment où les écrans sont créés.

Quelle est l'importance de la fonction 'CoinContextComposable' dans cet exemple ?

La fonction 'CoinContextComposable' est cruciale pour définir un scope dans lequel les dépendances de Coin peuvent être utilisées. Cela permet de s'assurer que les dépendances nécessaires sont disponibles pour les composables, facilitant l'injection et l'utilisation des objets comme les ViewModels.

Comment l'initialisation de Coin se fait-elle dans le code Android et iOS ?

Dans Android, Coin doit être initialisé dans la classe MainActivity avant la fonction 'setContent()'. Pour iOS, l'initialisation se fait dans le fichier Swift, où la fonction d'initialisation de Coin doit être appelée dans le bloc 'init'. Cela garantit que Coin est prêt avant l'utilisation des composables.

Quels comportements peuvent être observés lors de l'exécution de l'application sur un émulateur Android et un simulateur iOS ?

Lors de l'exécution de l'application, les ViewModels sont initialisés et détruits selon la navigation entre les écrans. Par exemple, lorsque l'on navigue vers l'écran de détail, le ViewModel de détail est initialisé, tandis que le ViewModel de l'écran d'accueil reste actif. En retournant à l'écran d'accueil, le ViewModel de détail est détruit, et celui de l'accueil reste le même, ce qui montre le cycle de vie des ViewModels dans une application multiplateforme.